home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 January: Mac OS SDK / Dev.CD Jan 98 SDK2.toast / Development Kits (Disc 2) / QuickDraw GX / Programming Stuff / GX Libraries / MappingLibrary.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-07  |  5.6 KB  |  167 lines  |  [TEXT/MPS ]
  1.  
  2. /*
  3.     File:        MappingLibrary.c
  4.  
  5.     Contains:    Mapping generation routines
  6.     
  7.     Written by:    Cary Clark, Georgiann Delaney, Michael Fairman, Dave Good, Robert Johnson, Keith McGreggor, Oliver Steele, David Van Brink, Chris Yerga
  8.     
  9.     Copyright:    © 1995 by Apple Computer, Inc., all rights reserved.
  10.  
  11.     Change History (most recent first):
  12.  
  13.          <2>      4/7/95    jtd        changed 'fract' to 'Fract'
  14.          <1>      1/9/95    JD        First checked in.
  15. */
  16.  
  17. #include "GraphicsLibraries.h"
  18.  
  19. static void PolyToPoint(const gxPolygon *poly, gxPoint *pt)
  20. {
  21.     register Fixed x = fixed1, y = fixed1;
  22.     gxPoint pt1, pt2;
  23.     if (poly->vectors > 1)
  24.     {   pt1.x = poly->vector[1].x - poly->vector[0].x;
  25.         pt1.y = poly->vector[1].y - poly->vector[0].y;
  26.         y = Magnitude(pt1.x, pt1.y);
  27.         switch (poly->vectors)
  28.         {   case 2:
  29.             break;
  30.             case 3:
  31.                 pt2.x = poly->vector[0].y - poly->vector[2].y;
  32.                 pt2.y = poly->vector[2].x - poly->vector[0].x;
  33.             goto calcX;
  34.             default:
  35.                 pt2.x = poly->vector[0].y - poly->vector[3].y;
  36.                 pt2.y = poly->vector[3].x - poly->vector[0].x;
  37.             calcX:
  38.                 x = VectorMultiplyDivide(2, &pt1.x, 1, &pt2.x, 1, y);
  39.             break;
  40.         }
  41.     }
  42.     pt->x = x;
  43.     pt->y = y;
  44. }
  45.  
  46. static void Map1Pt(const gxPoint *source, Fixed *dest)
  47. {
  48.     register Fixed *destPtr = dest;
  49.     register const gxPoint *srcPt = source;
  50.     *destPtr++ = fixed1;
  51.     *destPtr++ = 0;
  52.     *destPtr++ = 0;
  53.     *destPtr++ = 0;
  54.     *destPtr++ = fixed1;
  55.     *destPtr++ = 0;
  56.     *destPtr++ = srcPt[0].x;
  57.     *destPtr++ = srcPt[0].y;
  58.     *destPtr = fract1;
  59. }
  60.  
  61. static void Map2Pt(const gxPoint *source, Fixed *dest, Fixed scale)
  62. {
  63.     register Fixed *destPtr = dest;
  64.     register const gxPoint *srcPt = source;
  65.     *destPtr++ = FixedDivide(srcPt[1].y - srcPt[0].y, scale);
  66.     *destPtr++ = FixedDivide(srcPt[0].x - srcPt[1].x, scale);
  67.     *destPtr++ = 0;
  68.     *destPtr++ = FixedDivide(srcPt[1].x - srcPt[0].x, scale);
  69.     *destPtr++ = FixedDivide(srcPt[1].y - srcPt[0].y, scale);
  70.     *destPtr++ = 0;
  71.     *destPtr++ = srcPt[0].x;
  72.     *destPtr++ = srcPt[0].y;
  73.     *destPtr = fract1;
  74. }
  75.  
  76. static void Map3Pt(const gxPoint *source, Fixed *dest, Fixed scaleX, Fixed scaleY)
  77. {
  78.     register Fixed *destPtr = dest;
  79.     register const gxPoint *srcPt = source;
  80.     *destPtr++ = FixedDivide(srcPt[2].x - srcPt[0].x, scaleX);
  81.     *destPtr++ = FixedDivide(srcPt[2].y - srcPt[0].y, scaleX);
  82.     *destPtr++ = 0;
  83.     *destPtr++ = FixedDivide(srcPt[1].x - srcPt[0].x, scaleY);
  84.     *destPtr++ = FixedDivide(srcPt[1].y - srcPt[0].y, scaleY);
  85.     *destPtr++ = 0;
  86.     *destPtr++ = srcPt[0].x;
  87.     *destPtr++ = srcPt[0].y;
  88.     *destPtr = fract1;
  89. }
  90.  
  91. static void Map4Pt(const gxPoint *source, Fixed *dest, Fixed scaleX, Fixed scaleY)
  92. {
  93.     register Fixed *destPtr = dest;
  94.     register const gxPoint *srcPt = source;
  95.     Fract a1, a2;
  96.     Fixed x0, y0, x1, y1, x2, y2;
  97.  
  98.     x0 = srcPt[2].x - srcPt[0].x;
  99.     y0 = srcPt[2].y - srcPt[0].y;
  100.     x1 = srcPt[2].x - srcPt[1].x;
  101.     y1 = srcPt[2].y - srcPt[1].y;
  102.     x2 = srcPt[2].x - srcPt[3].x;
  103.     y2 = srcPt[2].y - srcPt[3].y;
  104.  
  105.     /* check if abs(x2) > abs(y2) */
  106.     if ( x2 > 0 ? y2 > 0 ? x2 > y2 : x2 > -y2 : y2 > 0 ? -x2 > y2 : x2 < y2)
  107.         a1 = FractDivide(MultiplyDivide(x0 - x1, y2, x2) - y0 + y1, MultiplyDivide(x1, y2, x2) - y1);
  108.     else
  109.         a1 = FractDivide(x0 - x1 - MultiplyDivide(y0 - y1, x2, y2), x1 - MultiplyDivide(y1, x2, y2));
  110.  
  111.     /* check if abs(x1) > abs(y1) */
  112.     if ( x1 > 0 ? y1 > 0 ? x1 > y1 : x1 > -y1 : y1 > 0 ? -x1 > y1 : x1 < y1)
  113.         a2 = FractDivide(y0 - y2 - MultiplyDivide(x0 - x2, y1, x1), y2 - MultiplyDivide(x2, y1, x1));
  114.     else
  115.         a2 = FractDivide(MultiplyDivide(y0 - y2, x1, y1) - x0 + x2, MultiplyDivide(y2, x1, y1) - x2);
  116.  
  117.     *destPtr++ = FixedDivide(FractMultiply(a2, srcPt[3].x) + srcPt[3].x - srcPt[0].x, scaleX);
  118.     *destPtr++ = FixedDivide(FractMultiply(a2, srcPt[3].y) + srcPt[3].y - srcPt[0].y, scaleX);
  119.     *destPtr++ = FixedDivide(a2, scaleX);
  120.     *destPtr++ = FixedDivide(FractMultiply(a1, srcPt[1].x) + srcPt[1].x - srcPt[0].x, scaleY);
  121.     *destPtr++ = FixedDivide(FractMultiply(a1, srcPt[1].y) + srcPt[1].y - srcPt[0].y, scaleY);
  122.     *destPtr++ = FixedDivide(a1, scaleY);
  123.     *destPtr++ = srcPt[0].x;
  124.     *destPtr++ = srcPt[0].y;
  125.     *destPtr = fract1;
  126. }
  127.  
  128. void PolyToPolyMap(const gxPolygon *source, const gxPolygon *dest, gxMapping *map)
  129. {
  130.     gxPoint tempPt;
  131.     gxMapping tempMap;
  132.     long vectors = source->vectors;
  133.  
  134.     if( vectors != dest->vectors && (vectors < 4 || dest->vectors < 4) ) {
  135.         GXPostGraphicsWarning(polygons_have_different_size_contours);
  136.         if (vectors > dest->vectors) vectors = dest->vectors;
  137.     }
  138.     PolyToPoint(source, &tempPt);
  139.     switch (vectors)
  140.     {   case 0:
  141.             ResetMapping(map);
  142.             break;
  143.         case 1:
  144.             Map1Pt(source->vector, &tempMap.map[0][0]);
  145.             InvertMapping(map, &tempMap);
  146.             Map1Pt(dest->vector, &tempMap.map[0][0]);
  147.             goto mapMap;
  148.         case 2:
  149.             Map2Pt(source->vector, &tempMap.map[0][0], tempPt.y);
  150.             InvertMapping(map, &tempMap);
  151.             Map2Pt(dest->vector, &tempMap.map[0][0], tempPt.y);
  152.             goto mapMap;
  153.         case 3:
  154.             Map3Pt(source->vector, &tempMap.map[0][0], tempPt.x, tempPt.y);
  155.             InvertMapping(map, &tempMap);
  156.             Map3Pt(dest->vector, &tempMap.map[0][0], tempPt.x, tempPt.y);
  157.             goto mapMap;
  158.         default:
  159.             Map4Pt(source->vector, &tempMap.map[0][0], tempPt.x, tempPt.y);
  160.             InvertMapping(map, &tempMap);
  161.             Map4Pt(dest->vector, &tempMap.map[0][0], tempPt.x, tempPt.y);
  162.         mapMap:
  163.             MapMapping(map, &tempMap);
  164.             break;
  165.     }
  166. }
  167.